home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / xen / interface / event_channel.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  5.6 KB  |  196 lines
  1. /******************************************************************************
  2.  * event_channel.h
  3.  *
  4.  * Event channels between domains.
  5.  *
  6.  * Copyright (c) 2003-2004, K A Fraser.
  7.  */
  8.  
  9. #ifndef __XEN_PUBLIC_EVENT_CHANNEL_H__
  10. #define __XEN_PUBLIC_EVENT_CHANNEL_H__
  11.  
  12. typedef uint32_t evtchn_port_t;
  13. DEFINE_GUEST_HANDLE(evtchn_port_t);
  14.  
  15. /*
  16.  * EVTCHNOP_alloc_unbound: Allocate a port in domain <dom> and mark as
  17.  * accepting interdomain bindings from domain <remote_dom>. A fresh port
  18.  * is allocated in <dom> and returned as <port>.
  19.  * NOTES:
  20.  *  1. If the caller is unprivileged then <dom> must be DOMID_SELF.
  21.  *  2. <rdom> may be DOMID_SELF, allowing loopback connections.
  22.  */
  23. #define EVTCHNOP_alloc_unbound      6
  24. struct evtchn_alloc_unbound {
  25.     /* IN parameters */
  26.     domid_t dom, remote_dom;
  27.     /* OUT parameters */
  28.     evtchn_port_t port;
  29. };
  30.  
  31. /*
  32.  * EVTCHNOP_bind_interdomain: Construct an interdomain event channel between
  33.  * the calling domain and <remote_dom>. <remote_dom,remote_port> must identify
  34.  * a port that is unbound and marked as accepting bindings from the calling
  35.  * domain. A fresh port is allocated in the calling domain and returned as
  36.  * <local_port>.
  37.  * NOTES:
  38.  *  2. <remote_dom> may be DOMID_SELF, allowing loopback connections.
  39.  */
  40. #define EVTCHNOP_bind_interdomain 0
  41. struct evtchn_bind_interdomain {
  42.     /* IN parameters. */
  43.     domid_t remote_dom;
  44.     evtchn_port_t remote_port;
  45.     /* OUT parameters. */
  46.     evtchn_port_t local_port;
  47. };
  48.  
  49. /*
  50.  * EVTCHNOP_bind_virq: Bind a local event channel to VIRQ <irq> on specified
  51.  * vcpu.
  52.  * NOTES:
  53.  *  1. A virtual IRQ may be bound to at most one event channel per vcpu.
  54.  *  2. The allocated event channel is bound to the specified vcpu. The binding
  55.  *     may not be changed.
  56.  */
  57. #define EVTCHNOP_bind_virq      1
  58. struct evtchn_bind_virq {
  59.     /* IN parameters. */
  60.     uint32_t virq;
  61.     uint32_t vcpu;
  62.     /* OUT parameters. */
  63.     evtchn_port_t port;
  64. };
  65.  
  66. /*
  67.  * EVTCHNOP_bind_pirq: Bind a local event channel to PIRQ <irq>.
  68.  * NOTES:
  69.  *  1. A physical IRQ may be bound to at most one event channel per domain.
  70.  *  2. Only a sufficiently-privileged domain may bind to a physical IRQ.
  71.  */
  72. #define EVTCHNOP_bind_pirq      2
  73. struct evtchn_bind_pirq {
  74.     /* IN parameters. */
  75.     uint32_t pirq;
  76. #define BIND_PIRQ__WILL_SHARE 1
  77.     uint32_t flags; /* BIND_PIRQ__* */
  78.     /* OUT parameters. */
  79.     evtchn_port_t port;
  80. };
  81.  
  82. /*
  83.  * EVTCHNOP_bind_ipi: Bind a local event channel to receive events.
  84.  * NOTES:
  85.  *  1. The allocated event channel is bound to the specified vcpu. The binding
  86.  *     may not be changed.
  87.  */
  88. #define EVTCHNOP_bind_ipi      7
  89. struct evtchn_bind_ipi {
  90.     uint32_t vcpu;
  91.     /* OUT parameters. */
  92.     evtchn_port_t port;
  93. };
  94.  
  95. /*
  96.  * EVTCHNOP_close: Close a local event channel <port>. If the channel is
  97.  * interdomain then the remote end is placed in the unbound state
  98.  * (EVTCHNSTAT_unbound), awaiting a new connection.
  99.  */
  100. #define EVTCHNOP_close          3
  101. struct evtchn_close {
  102.     /* IN parameters. */
  103.     evtchn_port_t port;
  104. };
  105.  
  106. /*
  107.  * EVTCHNOP_send: Send an event to the remote end of the channel whose local
  108.  * endpoint is <port>.
  109.  */
  110. #define EVTCHNOP_send          4
  111. struct evtchn_send {
  112.     /* IN parameters. */
  113.     evtchn_port_t port;
  114. };
  115.  
  116. /*
  117.  * EVTCHNOP_status: Get the current status of the communication channel which
  118.  * has an endpoint at <dom, port>.
  119.  * NOTES:
  120.  *  1. <dom> may be specified as DOMID_SELF.
  121.  *  2. Only a sufficiently-privileged domain may obtain the status of an event
  122.  *     channel for which <dom> is not DOMID_SELF.
  123.  */
  124. #define EVTCHNOP_status          5
  125. struct evtchn_status {
  126.     /* IN parameters */
  127.     domid_t  dom;
  128.     evtchn_port_t port;
  129.     /* OUT parameters */
  130. #define EVTCHNSTAT_closed    0  /* Channel is not in use.             */
  131. #define EVTCHNSTAT_unbound    1  /* Channel is waiting interdom connection.*/
  132. #define EVTCHNSTAT_interdomain    2  /* Channel is connected to remote domain. */
  133. #define EVTCHNSTAT_pirq        3  /* Channel is bound to a phys IRQ line.   */
  134. #define EVTCHNSTAT_virq        4  /* Channel is bound to a virtual IRQ line */
  135. #define EVTCHNSTAT_ipi        5  /* Channel is bound to a virtual IPI line */
  136.     uint32_t status;
  137.     uint32_t vcpu;           /* VCPU to which this channel is bound.   */
  138.     union {
  139.         struct {
  140.             domid_t dom;
  141.         } unbound; /* EVTCHNSTAT_unbound */
  142.         struct {
  143.             domid_t dom;
  144.             evtchn_port_t port;
  145.         } interdomain; /* EVTCHNSTAT_interdomain */
  146.         uint32_t pirq;        /* EVTCHNSTAT_pirq          */
  147.         uint32_t virq;        /* EVTCHNSTAT_virq          */
  148.     } u;
  149. };
  150.  
  151. /*
  152.  * EVTCHNOP_bind_vcpu: Specify which vcpu a channel should notify when an
  153.  * event is pending.
  154.  * NOTES:
  155.  *  1. IPI- and VIRQ-bound channels always notify the vcpu that initialised
  156.  *     the binding. This binding cannot be changed.
  157.  *  2. All other channels notify vcpu0 by default. This default is set when
  158.  *     the channel is allocated (a port that is freed and subsequently reused
  159.  *     has its binding reset to vcpu0).
  160.  */
  161. #define EVTCHNOP_bind_vcpu      8
  162. struct evtchn_bind_vcpu {
  163.     /* IN parameters. */
  164.     evtchn_port_t port;
  165.     uint32_t vcpu;
  166. };
  167.  
  168. /*
  169.  * EVTCHNOP_unmask: Unmask the specified local event-channel port and deliver
  170.  * a notification to the appropriate VCPU if an event is pending.
  171.  */
  172. #define EVTCHNOP_unmask          9
  173. struct evtchn_unmask {
  174.     /* IN parameters. */
  175.     evtchn_port_t port;
  176. };
  177.  
  178. struct evtchn_op {
  179.     uint32_t cmd; /* EVTCHNOP_* */
  180.     union {
  181.         struct evtchn_alloc_unbound    alloc_unbound;
  182.         struct evtchn_bind_interdomain bind_interdomain;
  183.         struct evtchn_bind_virq           bind_virq;
  184.         struct evtchn_bind_pirq           bind_pirq;
  185.         struct evtchn_bind_ipi           bind_ipi;
  186.         struct evtchn_close           close;
  187.         struct evtchn_send           send;
  188.         struct evtchn_status           status;
  189.         struct evtchn_bind_vcpu           bind_vcpu;
  190.         struct evtchn_unmask           unmask;
  191.     } u;
  192. };
  193. DEFINE_GUEST_HANDLE_STRUCT(evtchn_op);
  194.  
  195. #endif /* __XEN_PUBLIC_EVENT_CHANNEL_H__ */
  196.